package com.ben.multiple.jsoup;

import ma.glasnost.orika.MapperFacade;
import ma.glasnost.orika.impl.DefaultMapperFactory;
import ma.glasnost.orika.metadata.TypeFactory;

import java.util.List;
import java.util.Set;

public class BeanMapper {

    private static MapperFacade mapper = new DefaultMapperFactory.Builder().build().getMapperFacade();

    /**
     * 简单复制 对象
     *
     * @param source           源对象
     * @param destinationClass 目标类型
     * @param <S>              原类型
     * @param <D>              目标类型
     * @return 目标对象
     */
    public static <S, D> D map(S source, Class<D> destinationClass) {
        return mapper.map(source, destinationClass);
    }

    /**
     * 高性能复制 对象
     *
     * @param source           源对象
     * @param sourceClass      源类型
     * @param destinationClass 目标类型
     * @param <S>              源类型
     * @param <D>              目标类型
     * @return 目标对象
     */
    public static <S, D> D map(S source, Class<S> sourceClass, Class<D> destinationClass) {
        return mapper.map(source, TypeFactory.valueOf(sourceClass), TypeFactory.valueOf(destinationClass));
    }

    /**
     * 高性能复制 泛型对象；比如 Map<K,V> ；泛型中不能有枚举
     *
     * @param source           S
     * @param sourceClass      sourceClass
     * @param destinationClass destinationClass
     * @param params           Class<?>...
     * @param <S>              源类型
     * @param <D>              目标类型
     * @return 目标对象
     */
    public static <S, D> D map(S source, Class<S> sourceClass, Class<D> destinationClass, Class<?>... params) {
        ma.glasnost.orika.metadata.Type<D> dType = TypeFactory.valueOf(destinationClass, params);
        return mapper.map(source, TypeFactory.valueOf(sourceClass), dType);
    }

    /**
     * 高性能复制 集合
     *
     * @param source           源对象集合
     * @param sourceClass      源类型
     * @param destinationClass 目标类型
     * @param <S>              源类型
     * @param <D>              目标类型
     * @return 目标对象集合
     */
    public static <S, D> Set<D> mapAsSet(Iterable<S> source, Class<S> sourceClass, Class<D> destinationClass) {
        return mapper.mapAsSet(source, TypeFactory.valueOf(sourceClass), TypeFactory.valueOf(destinationClass));
    }

    /**
     * 高性能复制 集合
     *
     * @param source           源对象集合
     * @param sourceClass      源类型
     * @param destinationClass 目标类型
     * @param <S>              源类型
     * @param <D>              目标类型
     * @return 目标对象集合
     */
    public static <S, D> List<D> mapAsList(Iterable<S> source, Class<S> sourceClass, Class<D> destinationClass) {
        return mapper.mapAsList(source, TypeFactory.valueOf(sourceClass), TypeFactory.valueOf(destinationClass));
    }
}
